#include "ap/APCPSignalManager.h"
#include <transfer/utils.h>

namespace ecarx::transfer {

    bool APCPSignalManager::isAPCPReady() const {
        if (mAPCPConn != nullptr) {
            return mAPCPConn->getState() == NetState::Ready;
        }
        return false;
    }

    void APCPSignalManager::setStatus2CpNormal(sdb::ApStatus value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::Status2CpNormal;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setTmprUnit(sdb::TmprUnit value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::TmprUnit;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setLangType(sdb::LangType value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::LangType;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setMileUnit(sdb::TripMileUnit value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::MileUnit;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSpdUnit(sdb::TripSpdUnit value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SpdUnit;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setEgyFulUnit(sdb::TripEgyFulUnit value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::EgyFulUnit;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setTripRstReq(sdb::TripRstReq value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::TripRstReq;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setTripAutoRstMode(sdb::TripAutoRstMode value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::TripAutoRstMode;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setDrivingModeSync(sdb::DrvModReqType2IHU value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::DrivingModeSync;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setWheelAngleAlarmSwitch(uint8_t onoff1) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::WheelAngleAlarmSwitch;
        signal.value.int32Values = {(int32_t) onoff1};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setOverSpeedAlarmSwitch(uint8_t onoff1) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::OverSpeedAlarmSwitch;
        signal.value.int32Values = {(int32_t) onoff1};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setRearMirrorSelect(sdb::MirrorSelect value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::RearMirrorSelect;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setDrvrPfmncAlrmSync(uint8_t drvrpfmncwarnreq) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::DrvrPfmncAlrmSync;
        signal.value.int32Values = {(int32_t) drvrpfmncwarnreq};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setTripEduDisMode(sdb::TripEduDisModeReq value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::TripEduDisMode;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setWheelKeyModeReq(sdb::WheelModeReq value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::WheelKeyModeReq;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setDrivingModeSync2(sdb::DrvModReqType2IHU value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::DrivingModeSync2;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setTimeFormatTime(sdb::TimeFormat value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::TimeFormatTime;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setTimeFormatDate(sdb::TimeDate value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::TimeFormatDate;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setTirePressureUnit(sdb::TriePUnit value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::TirePressureUnit;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setDstShoUnit(sdb::DstShoUnit value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::DstShoUnit;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSetVolUnit(uint8_t volunit) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SetVolUnit;
        signal.value.int32Values = {(int32_t) volunit};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setHmiAutoShowMod(uint8_t onoff1) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::HmiAutoShowMod;
        signal.value.int32Values = {(int32_t) onoff1};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setMediaPlayInfoSync(MediaPlayInfoSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::MediaPlayInfoSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setMediaStatusInfoSync(MediaStatusInfoSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::MediaStatusInfoSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setVolChangeSync(VolChangeSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::VolChangeSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setBTCallInfoSync(BTCallInfoSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::BTCallInfoSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setNavTBTInfoSync(NavTBTInfoSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::NavTBTInfoSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setNavLaneInfoSync(NavLaneInfoSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::NavLaneInfoSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setNavETAInfoSync(NavETAInfoSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::NavETAInfoSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setNavTBTNextInfoSync(NavTBTNextInfoSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::NavTBTNextInfoSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setMediaCoverPackSync(MediaCoverPackSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::MediaCoverPackSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setDIMViewSet(sdb::DIMViewType value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::DIMViewSet;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setHmiThemeModReq(sdb::ThemeMod value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::HmiThemeModReq;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setIntrBriStst2DIM(sdb::CSDBritLvl value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::IntrBriStst2DIM;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setCustomKeyAction2DIM(sdb::CustomKeyAction value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::CustomKeyAction2DIM;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSoundVolLvlSet(sdb::SoundVolLvl value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SoundVolLvlSet;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setFaceRecIndcrFromDHU(uint8_t onoff1) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::FaceRecIndcrFromDHU;
        signal.value.int32Values = {(int32_t) onoff1};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setBTCallCoverSync(BTCallCoverSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::BTCallCoverSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setHmiThemeStyleSync(sdb::HmiThemeStyle value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::HmiThemeStyleSync;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setOverSpeedAlarmInfo(uint8_t none) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::OverSpeedAlarmInfo;
        signal.value.int32Values = {(int32_t) none};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setPwrSldgDoorStrgMusicSet(sdb::MusicSet value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::PwrSldgDoorStrgMusicSet;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setPwrSldgDoorStrgMusicTpeReq(sdb::MusicTpeReq value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::PwrSldgDoorStrgMusicTpeReq;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSeScrShrCmd(SeScrShrCmd value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SeScrShrCmd;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSnsrDrvrPfmncStsToDim(uint8_t snsrdrvrpfmncsts) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SnsrDrvrPfmncStsToDim;
        signal.value.int32Values = {(int32_t) snsrdrvrpfmncsts};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setResChrgStrTiSync(ResChrgStrTiSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::ResChrgStrTiSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setWirelsDevLostWarnSts(sdb::WarningSts value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::WirelsDevLostWarnSts;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSeScrShrBriSts(sdb::SeScrShrBriSts value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SeScrShrBriSts;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setAvasVolSwitchToDim(sdb::AvasVolSwitch value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::AvasVolSwitchToDim;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setAutoTimeEngineSync(AutoTimeEngineSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::AutoTimeEngineSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setHudDispActvReq(uint8_t onoff1) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::HudDispActvReq;
        signal.value.int32Values = {(int32_t) onoff1};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setHudSnowModeReq(uint8_t onoff1) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::HudSnowModeReq;
        signal.value.int32Values = {(int32_t) onoff1};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSetHUDARSwitch(uint8_t onoff1) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SetHUDARSwitch;
        signal.value.int32Values = {(int32_t) onoff1};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setGlbRstForSetgAndData(GlbRstForSetgAndData value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::GlbRstForSetgAndData;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setDriftModOnOff(uint8_t onoff1) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::DriftModOnOff;
        signal.value.int32Values = {(int32_t) onoff1};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setHudPrefInfoSet(sdb::HudPrefInfoSet value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::HudPrefInfoSet;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setDimNaviInfoSync(std::vector<uint8_t> value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::DimNaviInfoSync;
        signal.value.bytes = value;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setDimBTCallInfoSync(std::vector<uint8_t> value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::DimBTCallInfoSync;
        signal.value.bytes = value;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setDimMediaInfoSync(std::vector<uint8_t> value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::DimMediaInfoSync;
        signal.value.bytes = value;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setStatus2CpTimeSync(sdb::ApStatus value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::Status2CpTimeSync;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setTimeSync(TimeSync value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::TimeSync;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setStatus2CpAVAS(sdb::ApStatus value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::Status2CpAVAS;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setAvasVolSwitch(sdb::AvasVolSwitch value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::AvasVolSwitch;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setAvasVolTypeSync(sdb::AvasVolType value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::AvasVolTypeSync;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setAvasDiagnosisReq(sdb::AvasDigReq value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::AvasDiagnosisReq;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setStatus2CpHostInfo(sdb::ApStatus value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::Status2CpHostInfo;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSendDIDD0D0(SendDIDD0D0 value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SendDIDD0D0;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSendDIDD0D1(SendDIDD0D1 value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SendDIDD0D1;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSendDIDC012(SendDIDC012 value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SendDIDC012;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSendDIDD089(SendDIDD089 value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SendDIDD089;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setSendDIDD07F(SendDIDD07F value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::SendDIDD07F;
        auto bytes = utils::toBytes(value);
        signal.value.bytes = (std::vector<uint8_t>) bytes;
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setStatus2CpPower(sdb::ApStatus value) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::Status2CpPower;
        signal.value.int32Values = {(int32_t) value};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    void APCPSignalManager::setGameStartRequest(uint8_t none) const {
        Signal signal;
        signal.signalId = (int32_t)APCPSignalTX::GameStartRequest;
        signal.value.int32Values = {(int32_t) none};
        if (mAPCPConn != nullptr) {
            mAPCPConn->write(signal);
        }
    }

    sdb::CpStatus APCPSignalManager::getCpNormalStatus() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::CpNormalStatus);
        }
        if (signal.has_value()) {
            return sdb::CpStatus(signal->value.int32Values[0]);
        }
        return sdb::CpStatus(-1);
    }

    OdoInfo APCPSignalManager::getOdoInfo() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::OdoInfo);
        }
        if (signal.has_value()) {
            return utils::toValue<OdoInfo>(signal->value.bytes);
        }
        return OdoInfo{};
    }

    Trip1Mileage APCPSignalManager::getTrip1Mileage() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip1Mileage);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip1Mileage>(signal->value.bytes);
        }
        return Trip1Mileage{};
    }

    Trip1EgyUse APCPSignalManager::getTrip1EgyUse() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip1EgyUse);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip1EgyUse>(signal->value.bytes);
        }
        return Trip1EgyUse{};
    }

    Trip1EgyRec APCPSignalManager::getTrip1EgyRec() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip1EgyRec);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip1EgyRec>(signal->value.bytes);
        }
        return Trip1EgyRec{};
    }

    Trip1AVS APCPSignalManager::getTrip1AVS() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip1AVS);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip1AVS>(signal->value.bytes);
        }
        return Trip1AVS{};
    }

    Trip1EDT APCPSignalManager::getTrip1EDT() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip1EDT);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip1EDT>(signal->value.bytes);
        }
        return Trip1EDT{};
    }

    Trip2Mileage APCPSignalManager::getTrip2Mileage() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip2Mileage);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip2Mileage>(signal->value.bytes);
        }
        return Trip2Mileage{};
    }

    Trip2EgyUse APCPSignalManager::getTrip2EgyUse() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip2EgyUse);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip2EgyUse>(signal->value.bytes);
        }
        return Trip2EgyUse{};
    }

    Trip2EgyRec APCPSignalManager::getTrip2EgyRec() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip2EgyRec);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip2EgyRec>(signal->value.bytes);
        }
        return Trip2EgyRec{};
    }

    Trip2AVS APCPSignalManager::getTrip2AVS() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip2AVS);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip2AVS>(signal->value.bytes);
        }
        return Trip2AVS{};
    }

    Trip2EDT APCPSignalManager::getTrip2EDT() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip2EDT);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip2EDT>(signal->value.bytes);
        }
        return Trip2EDT{};
    }

    LeFrntTireMsgPSync APCPSignalManager::getLeFrntTireMsgPSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::LeFrntTireMsgPSync);
        }
        if (signal.has_value()) {
            return utils::toValue<LeFrntTireMsgPSync>(signal->value.bytes);
        }
        return LeFrntTireMsgPSync{};
    }

    RiFrntTireMsgPSync APCPSignalManager::getRiFrntTireMsgPSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::RiFrntTireMsgPSync);
        }
        if (signal.has_value()) {
            return utils::toValue<RiFrntTireMsgPSync>(signal->value.bytes);
        }
        return RiFrntTireMsgPSync{};
    }

    LeReTireMsgPSync APCPSignalManager::getLeReTireMsgPSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::LeReTireMsgPSync);
        }
        if (signal.has_value()) {
            return utils::toValue<LeReTireMsgPSync>(signal->value.bytes);
        }
        return LeReTireMsgPSync{};
    }

    RiReTireMsgPSync APCPSignalManager::getRiReTireMsgPSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::RiReTireMsgPSync);
        }
        if (signal.has_value()) {
            return utils::toValue<RiReTireMsgPSync>(signal->value.bytes);
        }
        return RiReTireMsgPSync{};
    }

    LeFrntTireMsgTSync APCPSignalManager::getLeFrntTireMsgTSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::LeFrntTireMsgTSync);
        }
        if (signal.has_value()) {
            return utils::toValue<LeFrntTireMsgTSync>(signal->value.bytes);
        }
        return LeFrntTireMsgTSync{};
    }

    RiFrntTireMsgTSync APCPSignalManager::getRiFrntTireMsgTSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::RiFrntTireMsgTSync);
        }
        if (signal.has_value()) {
            return utils::toValue<RiFrntTireMsgTSync>(signal->value.bytes);
        }
        return RiFrntTireMsgTSync{};
    }

    LeReTireMsgTSync APCPSignalManager::getLeReTireMsgTSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::LeReTireMsgTSync);
        }
        if (signal.has_value()) {
            return utils::toValue<LeReTireMsgTSync>(signal->value.bytes);
        }
        return LeReTireMsgTSync{};
    }

    RiReTireMsgTSync APCPSignalManager::getRiReTireMsgTSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::RiReTireMsgTSync);
        }
        if (signal.has_value()) {
            return utils::toValue<RiReTireMsgTSync>(signal->value.bytes);
        }
        return RiReTireMsgTSync{};
    }

    LeFrntTireSymbolSync APCPSignalManager::getLeFrntTireSymbolSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::LeFrntTireSymbolSync);
        }
        if (signal.has_value()) {
            return utils::toValue<LeFrntTireSymbolSync>(signal->value.bytes);
        }
        return LeFrntTireSymbolSync{};
    }

    RiFrntTireSymbolSync APCPSignalManager::getRiFrntTireSymbolSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::RiFrntTireSymbolSync);
        }
        if (signal.has_value()) {
            return utils::toValue<RiFrntTireSymbolSync>(signal->value.bytes);
        }
        return RiFrntTireSymbolSync{};
    }

    LeReTireSymbolSync APCPSignalManager::getLeReTireSymbolSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::LeReTireSymbolSync);
        }
        if (signal.has_value()) {
            return utils::toValue<LeReTireSymbolSync>(signal->value.bytes);
        }
        return LeReTireSymbolSync{};
    }

    RiReTireSymbolSync APCPSignalManager::getRiReTireSymbolSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::RiReTireSymbolSync);
        }
        if (signal.has_value()) {
            return utils::toValue<RiReTireSymbolSync>(signal->value.bytes);
        }
        return RiReTireSymbolSync{};
    }

    sdb::WheelKeyEvent APCPSignalManager::getAdasHardKeyTop() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AdasHardKeyTop);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getAdasHardKeyBottom() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AdasHardKeyBottom);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getAdasHardKeyLeft() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AdasHardKeyLeft);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getAdasHardKeyRight() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AdasHardKeyRight);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getAdasHardKeyConfirm() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AdasHardKeyConfirm);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getAdasHardKeyResume() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AdasHardKeyResume);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getAdasHardKeyCancel() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AdasHardKeyCancel);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getHardKeyTop() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::HardKeyTop);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getHardKeyBottom() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::HardKeyBottom);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getHardKeyLeft() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::HardKeyLeft);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getHardKeyRight() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::HardKeyRight);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getHardKeyConfirm() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::HardKeyConfirm);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getHardKeyVR() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::HardKeyVR);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getHardKeyCustom() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::HardKeyCustom);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getHardKeyMenu() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::HardKeyMenu);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyEvent APCPSignalManager::getHardKeyMute() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::HardKeyMute);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyEvent(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyEvent(-1);
    }

    sdb::WheelKeyModeStatus APCPSignalManager::getWheelKeyModeSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::WheelKeyModeSync);
        }
        if (signal.has_value()) {
            return sdb::WheelKeyModeStatus(signal->value.int32Values[0]);
        }
        return sdb::WheelKeyModeStatus(-1);
    }

    DTEChrgInfo APCPSignalManager::getDTEChrgInfo() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::DTEChrgInfo);
        }
        if (signal.has_value()) {
            return utils::toValue<DTEChrgInfo>(signal->value.bytes);
        }
        return DTEChrgInfo{};
    }

    VehSpdIndcdInfo APCPSignalManager::getVehSpdIndcdInfo() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::VehSpdIndcdInfo);
        }
        if (signal.has_value()) {
            return utils::toValue<VehSpdIndcdInfo>(signal->value.bytes);
        }
        return VehSpdIndcdInfo{};
    }

    DTEFuelInfo APCPSignalManager::getDTEFuelInfo() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::DTEFuelInfo);
        }
        if (signal.has_value()) {
            return utils::toValue<DTEFuelInfo>(signal->value.bytes);
        }
        return DTEFuelInfo{};
    }

    sdb::SoundVolLvl APCPSignalManager::getSoundVolLvl() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::SoundVolLvl);
        }
        if (signal.has_value()) {
            return sdb::SoundVolLvl(signal->value.int32Values[0]);
        }
        return sdb::SoundVolLvl(-1);
    }

    CPLogSync APCPSignalManager::getCPLogSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::CPLogSync);
        }
        if (signal.has_value()) {
            return utils::toValue<CPLogSync>(signal->value.bytes);
        }
        return CPLogSync{};
    }

    DTEInfo APCPSignalManager::getDTEInfo() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::DTEInfo);
        }
        if (signal.has_value()) {
            return utils::toValue<DTEInfo>(signal->value.bytes);
        }
        return DTEInfo{};
    }

    ChrgRemainPercent APCPSignalManager::getChrgRemainPercent() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::ChrgRemainPercent);
        }
        if (signal.has_value()) {
            return utils::toValue<ChrgRemainPercent>(signal->value.bytes);
        }
        return ChrgRemainPercent{};
    }

    int32_t APCPSignalManager::getFuelRemainPercent() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::FuelRemainPercent);
        }
        if (signal.has_value()) {
            return static_cast<int32_t>(signal->value.int32Values[0]);
        }
        return -1;
    }

    Trip1AFC APCPSignalManager::getTrip1AFC() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip1AFC);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip1AFC>(signal->value.bytes);
        }
        return Trip1AFC{};
    }

    Trip1AEC APCPSignalManager::getTrip1AEC() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip1AEC);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip1AEC>(signal->value.bytes);
        }
        return Trip1AEC{};
    }

    Trip2AFC APCPSignalManager::getTrip2AFC() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip2AFC);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip2AFC>(signal->value.bytes);
        }
        return Trip2AFC{};
    }

    Trip2AEC APCPSignalManager::getTrip2AEC() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip2AEC);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip2AEC>(signal->value.bytes);
        }
        return Trip2AEC{};
    }

    sdb::SeScrShrRpsStsEnum APCPSignalManager::getSeScrShrRps() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::SeScrShrRps);
        }
        if (signal.has_value()) {
            return sdb::SeScrShrRpsStsEnum(signal->value.int32Values[0]);
        }
        return sdb::SeScrShrRpsStsEnum(-1);
    }

    sdb::ACCICCStsEnum APCPSignalManager::getACCICCSts() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::ACCICCSts);
        }
        if (signal.has_value()) {
            return sdb::ACCICCStsEnum(signal->value.int32Values[0]);
        }
        return sdb::ACCICCStsEnum(-1);
    }

    sdb::DIMViewType APCPSignalManager::getDIMViewSts() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::DIMViewSts);
        }
        if (signal.has_value()) {
            return sdb::DIMViewType(signal->value.int32Values[0]);
        }
        return sdb::DIMViewType(-1);
    }

    int32_t APCPSignalManager::getODO200mElcUse() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::ODO200mElcUse);
        }
        if (signal.has_value()) {
            return static_cast<int32_t>(signal->value.int32Values[0]);
        }
        return -1;
    }

    int32_t APCPSignalManager::getODO200mFueUse() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::ODO200mFueUse);
        }
        if (signal.has_value()) {
            return static_cast<int32_t>(signal->value.int32Values[0]);
        }
        return -1;
    }

    int32_t APCPSignalManager::getNavActvMenuReqSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::NavActvMenuReqSync);
        }
        if (signal.has_value()) {
            return static_cast<int32_t>(signal->value.int32Values[0]);
        }
        return -1;
    }

    AD_Timegap APCPSignalManager::getAD_Timegap() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_Timegap);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_Timegap>(signal->value.bytes);
        }
        return AD_Timegap{};
    }

    AD_AdjustTimeGap APCPSignalManager::getAD_AdjustTimeGap() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_AdjustTimeGap);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_AdjustTimeGap>(signal->value.bytes);
        }
        return AD_AdjustTimeGap{};
    }

    AD_LongitudinalStatus_Lamp APCPSignalManager::getAD_LongitudinalStatus_Lamp() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_LongitudinalStatus_Lamp);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_LongitudinalStatus_Lamp>(signal->value.bytes);
        }
        return AD_LongitudinalStatus_Lamp{};
    }

    AD_Longitudina_AdjustSetSpeed APCPSignalManager::getAD_Longitudina_AdjustSetSpeed() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_Longitudina_AdjustSetSpeed);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_Longitudina_AdjustSetSpeed>(signal->value.bytes);
        }
        return AD_Longitudina_AdjustSetSpeed{};
    }

    AD_AdasTTPa APCPSignalManager::getAD_AdasTTPa() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_AdasTTPa);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_AdasTTPa>(signal->value.bytes);
        }
        return AD_AdasTTPa{};
    }

    AD_PA_ADAS_TSI APCPSignalManager::getAD_PA_ADAS_TSI() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_ADAS_TSI);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_ADAS_TSI>(signal->value.bytes);
        }
        return AD_PA_ADAS_TSI{};
    }

    AD_PA_MovObject_N APCPSignalManager::getAD_PA_MovObject_N() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_MovObject_N);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_MovObject_N>(signal->value.bytes);
        }
        return AD_PA_MovObject_N{};
    }

    AD_PA_StaObject_N APCPSignalManager::getAD_PA_StaObject_N() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_StaObject_N);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_StaObject_N>(signal->value.bytes);
        }
        return AD_PA_StaObject_N{};
    }

    AD_PA_ADAS_Line APCPSignalManager::getAD_PA_ADAS_Line() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_ADAS_Line);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_ADAS_Line>(signal->value.bytes);
        }
        return AD_PA_ADAS_Line{};
    }

    AD_PA_ADAS_Line_Func APCPSignalManager::getAD_PA_ADAS_Line_Func() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_ADAS_Line_Func);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_ADAS_Line_Func>(signal->value.bytes);
        }
        return AD_PA_ADAS_Line_Func{};
    }

    AD_PA_ADAS_FCTA APCPSignalManager::getAD_PA_ADAS_FCTA() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_ADAS_FCTA);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_ADAS_FCTA>(signal->value.bytes);
        }
        return AD_PA_ADAS_FCTA{};
    }

    AD_PA_ADAS_RCW APCPSignalManager::getAD_PA_ADAS_RCW() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_ADAS_RCW);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_ADAS_RCW>(signal->value.bytes);
        }
        return AD_PA_ADAS_RCW{};
    }

    AD_PA_StopLine APCPSignalManager::getAD_PA_StopLine() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_StopLine);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_StopLine>(signal->value.bytes);
        }
        return AD_PA_StopLine{};
    }

    AD_PA_CrossWalkDisp APCPSignalManager::getAD_PA_CrossWalkDisp() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_CrossWalkDisp);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_CrossWalkDisp>(signal->value.bytes);
        }
        return AD_PA_CrossWalkDisp{};
    }

    AD_PA_ADAS_Arrow APCPSignalManager::getAD_PA_ADAS_Arrow() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_ADAS_Arrow);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_ADAS_Arrow>(signal->value.bytes);
        }
        return AD_PA_ADAS_Arrow{};
    }

    AD_PA_ADAS_LineRamp APCPSignalManager::getAD_PA_ADAS_LineRamp() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_ADAS_LineRamp);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_ADAS_LineRamp>(signal->value.bytes);
        }
        return AD_PA_ADAS_LineRamp{};
    }

    AD_PA_TLA_LAMP APCPSignalManager::getAD_PA_TLA_LAMP() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_TLA_LAMP);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_TLA_LAMP>(signal->value.bytes);
        }
        return AD_PA_TLA_LAMP{};
    }

    AD_PA_ADAS_DOW APCPSignalManager::getAD_PA_ADAS_DOW() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_ADAS_DOW);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_ADAS_DOW>(signal->value.bytes);
        }
        return AD_PA_ADAS_DOW{};
    }

    AD_PA_BoundaryWarn APCPSignalManager::getAD_PA_BoundaryWarn() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_BoundaryWarn);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_BoundaryWarn>(signal->value.bytes);
        }
        return AD_PA_BoundaryWarn{};
    }

    AD_PA_LCAleft_animation APCPSignalManager::getAD_PA_LCAleft_animation() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_LCAleft_animation);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_LCAleft_animation>(signal->value.bytes);
        }
        return AD_PA_LCAleft_animation{};
    }

    AD_PA_LCAright_animation APCPSignalManager::getAD_PA_LCAright_animation() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_LCAright_animation);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_LCAright_animation>(signal->value.bytes);
        }
        return AD_PA_LCAright_animation{};
    }

    AD_PA_LaneChangeDisp APCPSignalManager::getAD_PA_LaneChangeDisp() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_LaneChangeDisp);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_LaneChangeDisp>(signal->value.bytes);
        }
        return AD_PA_LaneChangeDisp{};
    }

    AD_PA_VehiclePathDisp APCPSignalManager::getAD_PA_VehiclePathDisp() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_VehiclePathDisp);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_VehiclePathDisp>(signal->value.bytes);
        }
        return AD_PA_VehiclePathDisp{};
    }

    AD_PA_G_pilot_DIMLightDisp APCPSignalManager::getAD_PA_G_pilot_DIMLightDisp() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_G_pilot_DIMLightDisp);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_G_pilot_DIMLightDisp>(signal->value.bytes);
        }
        return AD_PA_G_pilot_DIMLightDisp{};
    }

    AD_PA_SC_Override APCPSignalManager::getAD_PA_SC_Override() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_SC_Override);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_SC_Override>(signal->value.bytes);
        }
        return AD_PA_SC_Override{};
    }

    AD_PA_LateralOffsetDisp APCPSignalManager::getAD_PA_LateralOffsetDisp() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_LateralOffsetDisp);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_LateralOffsetDisp>(signal->value.bytes);
        }
        return AD_PA_LateralOffsetDisp{};
    }

    AD_PA_ADAS_Tunnel APCPSignalManager::getAD_PA_ADAS_Tunnel() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_ADAS_Tunnel);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_ADAS_Tunnel>(signal->value.bytes);
        }
        return AD_PA_ADAS_Tunnel{};
    }

    AD_PA_TLA_LeftLAMP APCPSignalManager::getAD_PA_TLA_LeftLAMP() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_TLA_LeftLAMP);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_TLA_LeftLAMP>(signal->value.bytes);
        }
        return AD_PA_TLA_LeftLAMP{};
    }

    AD_PA_TLA_RightLAMP APCPSignalManager::getAD_PA_TLA_RightLAMP() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_TLA_RightLAMP);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_TLA_RightLAMP>(signal->value.bytes);
        }
        return AD_PA_TLA_RightLAMP{};
    }

    AD_PA_VehiclePathDisp_Func APCPSignalManager::getAD_PA_VehiclePathDisp_Func() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AD_PA_VehiclePathDisp_Func);
        }
        if (signal.has_value()) {
            return utils::toValue<AD_PA_VehiclePathDisp_Func>(signal->value.bytes);
        }
        return AD_PA_VehiclePathDisp_Func{};
    }

    MaintainInfoSync APCPSignalManager::getMaintainInfoSync() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::MaintainInfoSync);
        }
        if (signal.has_value()) {
            return utils::toValue<MaintainInfoSync>(signal->value.bytes);
        }
        return MaintainInfoSync{};
    }

    FaultAlarmNofitfy APCPSignalManager::getFaultAlarmNofitfy() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::FaultAlarmNofitfy);
        }
        if (signal.has_value()) {
            return utils::toValue<FaultAlarmNofitfy>(signal->value.bytes);
        }
        return FaultAlarmNofitfy{};
    }

    int32_t APCPSignalManager::getHudActvStatus() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::HudActvStatus);
        }
        if (signal.has_value()) {
            return static_cast<int32_t>(signal->value.int32Values[0]);
        }
        return -1;
    }

    int32_t APCPSignalManager::getHudSnowModeSts() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::HudSnowModeSts);
        }
        if (signal.has_value()) {
            return static_cast<int32_t>(signal->value.int32Values[0]);
        }
        return -1;
    }

    Trip3Mileage APCPSignalManager::getTrip3Mileage() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip3Mileage);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip3Mileage>(signal->value.bytes);
        }
        return Trip3Mileage{};
    }

    Trip3AVS APCPSignalManager::getTrip3AVS() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip3AVS);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip3AVS>(signal->value.bytes);
        }
        return Trip3AVS{};
    }

    Trip3EDT APCPSignalManager::getTrip3EDT() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip3EDT);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip3EDT>(signal->value.bytes);
        }
        return Trip3EDT{};
    }

    Trip3AFC APCPSignalManager::getTrip3AFC() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip3AFC);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip3AFC>(signal->value.bytes);
        }
        return Trip3AFC{};
    }

    Trip3AEC APCPSignalManager::getTrip3AEC() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip3AEC);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip3AEC>(signal->value.bytes);
        }
        return Trip3AEC{};
    }

    Trip0AEC APCPSignalManager::getTrip0AEC() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::Trip0AEC);
        }
        if (signal.has_value()) {
            return utils::toValue<Trip0AEC>(signal->value.bytes);
        }
        return Trip0AEC{};
    }

    TripIEC APCPSignalManager::getTripIEC() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::TripIEC);
        }
        if (signal.has_value()) {
            return utils::toValue<TripIEC>(signal->value.bytes);
        }
        return TripIEC{};
    }

    sdb::DispTypOfElecDstToEmptyStatus APCPSignalManager::getDispTypOfElecDstToEmpty() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::DispTypOfElecDstToEmpty);
        }
        if (signal.has_value()) {
            return sdb::DispTypOfElecDstToEmptyStatus(signal->value.int32Values[0]);
        }
        return sdb::DispTypOfElecDstToEmptyStatus(-1);
    }

    sdb::CpStatus APCPSignalManager::getCpTimeSyncStatus() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::CpTimeSyncStatus);
        }
        if (signal.has_value()) {
            return sdb::CpStatus(signal->value.int32Values[0]);
        }
        return sdb::CpStatus(-1);
    }

    sdb::CpStatus APCPSignalManager::getCpAVASStatus() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::CpAVASStatus);
        }
        if (signal.has_value()) {
            return sdb::CpStatus(signal->value.int32Values[0]);
        }
        return sdb::CpStatus(-1);
    }

    sdb::AvasDigSts APCPSignalManager::getAvasDiagnosisSts() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::AvasDiagnosisSts);
        }
        if (signal.has_value()) {
            return sdb::AvasDigSts(signal->value.int32Values[0]);
        }
        return sdb::AvasDigSts(-1);
    }

    int32_t APCPSignalManager::getCSDTvalue() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::CSDTvalue);
        }
        if (signal.has_value()) {
            return static_cast<int32_t>(signal->value.int32Values[0]);
        }
        return -1;
    }

    DIDD0D0 APCPSignalManager::getDIDD0D0() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::DIDD0D0);
        }
        if (signal.has_value()) {
            return utils::toValue<DIDD0D0>(signal->value.bytes);
        }
        return DIDD0D0{};
    }

    DIDD0D1 APCPSignalManager::getDIDD0D1() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::DIDD0D1);
        }
        if (signal.has_value()) {
            return utils::toValue<DIDD0D1>(signal->value.bytes);
        }
        return DIDD0D1{};
    }

    DIDD089 APCPSignalManager::getDIDD089() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::DIDD089);
        }
        if (signal.has_value()) {
            return utils::toValue<DIDD089>(signal->value.bytes);
        }
        return DIDD089{};
    }

    DIDC006 APCPSignalManager::getDIDC006() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::DIDC006);
        }
        if (signal.has_value()) {
            return utils::toValue<DIDC006>(signal->value.bytes);
        }
        return DIDC006{};
    }

    DIDD07F APCPSignalManager::getDIDD07F() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::DIDD07F);
        }
        if (signal.has_value()) {
            return utils::toValue<DIDD07F>(signal->value.bytes);
        }
        return DIDD07F{};
    }

    int32_t APCPSignalManager::getStatusRequest2Ap() const {
        std::optional<Signal> signal;
        if (mAPCPConn != nullptr) {
            signal = mAPCPConn->read((int32_t)APCPSignalRX::StatusRequest2Ap);
        }
        if (signal.has_value()) {
            return static_cast<int32_t>(signal->value.int32Values[0]);
        }
        return -1;
    }

}
